home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 38 / Amiga Format CD38 (1999-03-15)(Future Publishing)(GB)(Track 1 of 3)[!][issue 1999-04].iso / -seriously_amiga- / programming / other / cyberxxxsrc / decoder / txt / decodemjpa.c < prev    next >
C/C++ Source or Header  |  1999-02-08  |  15KB  |  470 lines
  1. /*
  2. sc:c/sc opt txt/DecodeMJPA.c
  3. */
  4.  
  5. #include "Decode.h"
  6. #include "YUV.h"
  7. #include "Utils.h"
  8. #include "GlobalVars.h"
  9. #include "JPEG.h"
  10.  
  11. /* /// "define's und Variablen" */
  12. extern ulong bytes_pixel;
  13.  
  14. extern long xa_dither_flag;
  15.  
  16. extern uchar  *jpg_buff;
  17. extern long  jpg_bsize;
  18.  
  19. extern long   jpg_h_bnum;
  20. extern ulong  jpg_h_bbuf;
  21.  
  22. extern long   *jpg_quant_tables[JJ_NUM_QUANT_TBLS];
  23. extern ulong  jpg_marker;
  24. extern ulong  jpg_saw_SOI,jpg_saw_SOF,jpg_saw_SOS;
  25. extern ulong  jpg_saw_DHT,jpg_saw_DQT,jpg_saw_EOI;
  26. extern ulong  jpg_std_DHT_flag;
  27. extern long   jpg_dprec,jpg_height,jpg_width;
  28. extern long   jpg_num_comps,jpg_comps_in_scan;
  29. extern long   jpg_nxt_rst_num;
  30. extern long   jpg_rst_interval;
  31.  
  32. extern ulong xa_mjpg_kludge;
  33.  
  34. extern JJ_HUFF_TBL jpg_ac_huff[JJ_NUM_HUFF_TBLS];
  35. extern JJ_HUFF_TBL jpg_dc_huff[JJ_NUM_HUFF_TBLS];
  36.  
  37. extern COMPONENT_HDR jpg_comps[JPG_MAX_COMPS + 1];
  38.  
  39. extern long JJ_ZAG[DCTSIZE2+16];
  40.  
  41. extern ulong jpg_MCUbuf_size;
  42. extern uchar *jpg_Ybuf;
  43. extern uchar *jpg_Ubuf;
  44. extern uchar *jpg_Vbuf;
  45. extern short jpg_dct_buf[DCTSIZE2];
  46. /* \\\ */
  47.  
  48. struct MJPAData {
  49.   long *quantTab[JJ_NUM_QUANT_TBLS];
  50. };
  51.  
  52. /* /// "proto-types" */
  53. void __regargs (*mjpamcu211111) (uchar *to, ulong width, ulong height, ulong rowSize, ulong ipSize);
  54. ulong mjpa_decode_211111(uchar *image, ulong width, ulong height, ulong interleave, ulong row_offset, ulong imagex, ulong imagey);
  55. extern void jpg_huff_build(JJ_HUFF_TBL *htbl, uchar *hbits, uchar *hvals);
  56. extern ulong jpg_huffparse(register COMPONENT_HDR *comp, register short *dct_buf, ulong *qtab, uchar *OBuf);
  57. extern void j_rev_dct (short *data, uchar *outptr, uchar *rnglimit);
  58. extern void JPG_Setup_Samp_Limit_Table();
  59. extern void JPG_Free_Samp_Limit_Table();
  60. extern ulong jpg_std_DHT(void);
  61. extern ulong jpg_search_marker(ulong marker, uchar **data_ptr, long *data_size);
  62. extern ulong jpg_read_SOI(void);
  63. extern ulong jpg_read_SOF(void);
  64. extern ulong jpg_read_SOS(void);
  65. extern ulong jpg_read_DQT(void);
  66. extern ulong jpg_read_DRI(void);
  67. extern ulong jpg_read_DHT(void);
  68. extern ulong jpg_skip_marker(void);
  69. extern ulong jpg_get_marker(void);
  70. extern ulong jpg_read_markers(void);
  71. extern ulong jpg_read_EOI_marker(void);
  72. extern ulong jpg_read_RST_marker(void);
  73. extern void jpg_init_input(uchar *buff, long buff_size);
  74. extern void jpg_huff_reset(void);
  75. /* \\\ */
  76.  
  77. /* /// "mcu2hInnerTail" */
  78. #define mcu2hInnerTail(inc1,inc2) { \
  79.   skip++;                           \
  80.   if (skip==4)                      \
  81.     yp+=inc1;                       \
  82.   else                              \
  83.     if (skip>=8) {                  \
  84.       skip=0;                       \
  85.       yp+=inc2;                     \
  86.       up+=inc1;                     \
  87.       vp+=inc1;                     \
  88.     }                               \
  89. }
  90. /* \\\ */
  91.  
  92. /* /// "defines" */
  93. #define JPG_HANDLE_RST(rst_int,rst_cnt) {                                       \
  94.   if ( ((rst_int) && (rst_cnt==0)) /* || (jpg_marker)*/ ) {                     \
  95.     jpg_h_bbuf = 0;                                                             \
  96.     jpg_h_bnum = 0;                                                             \
  97.     /* DEBUG_LEVEL1 kprintf("  jRST_INT %d rst_cnt %d\n", rst_int,rst_cnt); */  \
  98.     if (jpg_marker) {                                                           \
  99.       /* DEBUG_LEVEL1 kprintf("  jpg_marker(%x)\n",jpg_marker); */              \
  100.       if (jpg_marker == M_EOI) {                                                \
  101.         jpg_saw_EOI = xaTRUE;                                                   \
  102.         return(xaTRUE);                                                         \
  103.       } else                                                                    \
  104.         if ( !((jpg_marker >= M_RST0) && (jpg_marker <= M_RST7))) {             \
  105.           /* kprintf("JPEG: unexp marker(%x)\n",jpg_marker); */                 \
  106.           return(xaFALSE);                                                      \
  107.         }                                                                       \
  108.       jpg_marker = 0;                                                           \
  109.     } else                                                                      \
  110.       if (jpg_read_RST_marker()==xaFALSE) {                                     \
  111.         /* kprintf("RST marker false\n"); */                                    \
  112.         return(xaFALSE);                                                        \
  113.       }                                                                         \
  114.       jpg_comps[0].dc = jpg_comps[1].dc = jpg_comps[2].dc = 0;                  \
  115.       rst_cnt = rst_int;                                                        \
  116.   } else                                                                        \
  117.     rst_cnt--;                                                                  \
  118. };
  119.  
  120. #define JPG_TST_MARKER(rst_int,rst_cnt) {                          \
  121.   if (jpg_marker) {                                                \
  122.     /* DEBUG_LEVEL1 kprintf("  jpg_marker(%x)\n",jpg_marker); */   \
  123.     if (jpg_marker == M_EOI) {                                     \
  124.       jpg_saw_EOI = xaTRUE;                                        \
  125.       /* return(xaTRUE); */                                        \
  126.      } else                                                        \
  127.        if ( !((jpg_marker >= M_RST0) && (jpg_marker <= M_RST7))) { \
  128.          /* kprintf("JPEG: unexp marker(%x)\n",jpg_marker); */     \
  129.          return(xaFALSE);                                          \
  130.        } else {                                                    \
  131.          jpg_comps[0].dc = jpg_comps[1].dc = jpg_comps[2].dc = 0;  \
  132.          rst_cnt = rst_int;                                        \
  133.          jpg_marker = 0;                                           \
  134.          jpg_h_bbuf = 0;                                           \
  135.          jpg_h_bnum = 0;                                           \
  136.        }                                                           \
  137.   }                                                                \
  138. };
  139. /* \\\ */
  140.  
  141. /* /// "mjpaMCU211111toRGB()" */
  142. void __regargs mjpaMCU211111toRGB(uchar *to,
  143.                                   ulong width,
  144.                                   ulong height,
  145.                                   ulong rowSize,
  146.                                   ulong ipSize)
  147. {
  148.   long *ubTab=yuvTab->ubTab;
  149.   long *vrTab=yuvTab->vrTab;
  150.   long *ugTab=yuvTab->ugTab;
  151.   long *vgTab=yuvTab->vgTab;
  152.   long *yTab=yuvTab->yTab;
  153.   uchar *yBuf=yuvBuf->yBuf;
  154.   uchar *uBuf=yuvBuf->uBuf;
  155.   uchar *vBuf=yuvBuf->vBuf;
  156.   ulong oipSize=ipSize;
  157.   ipSize<<=1;
  158.  
  159.   while (height>0) {
  160.     uchar *iptr=(uchar *)to;
  161.     uchar *yptr=yBuf;
  162.     uchar *uptr=uBuf;
  163.     uchar *vptr=vBuf;
  164.     ulong xi, yi, skip;
  165.     for (yi=0; yi<8; yi++) {
  166.       uchar *ip=iptr;
  167.       uchar *yp=yptr;
  168.       uchar *up=uptr;
  169.       uchar *vp=vptr;
  170.       if (height<=0) return;
  171.       xi=width;
  172.       skip=0;
  173.       while (xi--) {
  174.         ulong u0=*up++;
  175.         ulong v0=*vp++;
  176.         long cr=vrTab[v0];
  177.         long cg=vgTab[v0]+ugTab[u0];
  178.         long cb=ubTab[u0];
  179.         iDecYUVRGB(ip,*yp++,cr,cg,cb);
  180.         iDecYUVRGB(ip,*yp++,cr,cg,cb);
  181.         mcu2hInnerTail(56,56);
  182.       }
  183.       yptr+=8;
  184.       uptr+=8;
  185.       vptr+=8;
  186.       height--;
  187.       mycopymem((ulong *)iptr,(ulong *)(iptr+oipSize),oipSize);
  188.       iptr+=ipSize;
  189.     }
  190.     yBuf+=rowSize<<1;
  191.     uBuf+=rowSize;
  192.     vBuf+=rowSize;
  193.   }
  194. }
  195. /* \\\ */
  196.  
  197. /* /// "mjpaMCU211111to332()" */
  198. void __regargs mjpaMCU211111to332(uchar *to,
  199.                                   ulong width,
  200.                                   ulong height,
  201.                                   ulong rowSize,
  202.                                   ulong ipSize)
  203. {
  204.   long *ubTab=yuvTab->ubTab;
  205.   long *vrTab=yuvTab->vrTab;
  206.   long *ugTab=yuvTab->ugTab;
  207.   long *vgTab=yuvTab->vgTab;
  208.   long *yTab=yuvTab->yTab;
  209.   uchar *yBuf=yuvBuf->yBuf;
  210.   uchar *uBuf=yuvBuf->uBuf;
  211.   uchar *vBuf=yuvBuf->vBuf;
  212.   ulong oipSize=ipSize;
  213.   ipSize<<=1;
  214.  
  215.   while (height>0) {
  216.     uchar *iptr=(uchar *)to;
  217.     uchar *yptr=yBuf;
  218.     uchar *uptr=uBuf;
  219.     uchar *vptr=vBuf;
  220.     ulong xi, yi, skip;
  221.     for (yi=0; yi<8; yi++) {
  222.       uchar *ip=iptr;
  223.       uchar *yp=yptr;
  224.       uchar *up=uptr;
  225.       uchar *vp=vptr;
  226.       if (height<=0) return;
  227.       xi=width;
  228.       skip=0;
  229.       while (xi--) {
  230.         if (gray) {
  231.           ip[0]=yp[0];
  232.           ip[1]=yp[1];
  233.           ip+=2;
  234.           yp+=2;
  235.         } else {
  236.           ulong u0=*up++;
  237.           ulong v0=*vp++;
  238.           long cr=vrTab[v0];
  239.           long cg=vgTab[v0]+ugTab[u0];
  240.           long cb=ubTab[u0];
  241.           DecYUV332(ip,*yp++,cr,cg,cb);
  242.           DecYUV332(ip,*yp++,cr,cg,cb);
  243.         }
  244.         mcu2hInnerTail(56,56);
  245.       }
  246.       yptr+=8;
  247.       uptr+=8;
  248.       vptr+=8;
  249.       height--;
  250.       mycopymem((ulong *)iptr,(ulong *)(iptr+oipSize),oipSize);
  251.       iptr+=ipSize;
  252.     }
  253.     yBuf+=rowSize<<1;
  254.     uBuf+=rowSize;
  255.     vBuf+=rowSize;
  256.   }
  257. }
  258. /* \\\ */
  259.  
  260. /* /// "mjpaMCU211111to332Dith()" */
  261. void __regargs mjpaMCU211111to332Dith(uchar *to,
  262.                                       ulong width,
  263.                                       ulong height,
  264.                                       ulong rowSize,
  265.                                       ulong ipSize)
  266. {
  267.   long *ubTab=yuvTab->ubTab;
  268.   long *vrTab=yuvTab->vrTab;
  269.   long *ugTab=yuvTab->ugTab;
  270.   long *vgTab=yuvTab->vgTab;
  271.   long *yTab=yuvTab->yTab;
  272.   uchar *yBuf=yuvBuf->yBuf;
  273.   uchar *uBuf=yuvBuf->uBuf;
  274.   uchar *vBuf=yuvBuf->vBuf;
  275.   ulong oipSize=ipSize;
  276.   ipSize<<=1;
  277.  
  278.   while (height>0) {
  279.     uchar *iptr=(uchar *)to;
  280.     uchar *yptr=yBuf;
  281.     uchar *uptr=uBuf;
  282.     uchar *vptr=vBuf;
  283.     ulong xi, yi, skip;
  284.     for (yi=0; yi<8; yi++) {
  285.       uchar *ip=iptr;
  286.       uchar *yp=yptr;
  287.       uchar *up=uptr;
  288.       uchar *vp=vptr;
  289.       long re=0, ge=0, be=0;
  290.       if (height<=0) return;
  291.       xi=width;
  292.       skip=0;
  293.       while (xi--) {
  294.         ulong u0=*up++;
  295.         ulong v0=*vp++;
  296.         long cr=vrTab[v0];
  297.         long cg=vgTab[v0]+ugTab[u0];
  298.         long cb=ubTab[u0];
  299.         DecYUV332Dith(*ip++,*yp++,cr,cg,cb);
  300.         DecYUV332Dith(*ip++,*yp++,cr,cg,cb);
  301.         mcu2hInnerTail(56,56);
  302.       }
  303.       yptr+=8;
  304.       uptr+=8;
  305.       vptr+=8;
  306.       height--;
  307.       mycopymem((ulong *)iptr,(ulong *)(iptr+oipSize),oipSize);
  308.       iptr+=ipSize;
  309.     }
  310.     yBuf+=rowSize<<1;
  311.     uBuf+=rowSize;
  312.     vBuf+=rowSize;
  313.   }
  314. }
  315. /* \\\ */
  316.  
  317. /* /// "mjpa_decode_211111()" */
  318. ulong mjpa_decode_211111(uchar *image, ulong width, ulong height, ulong interleave, ulong row_offset, ulong imagex, ulong imagey)
  319. {
  320.   uchar *iptr = image;
  321.   ulong x,mcu_cols,mcu_rows;
  322.   ulong *qtab0,*qtab1,*qtab2;
  323.   uchar *Ybuf,*Ubuf,*Vbuf;
  324.   ulong rst_count;
  325.   ulong orow_size = imagex * bytes_pixel;
  326.  
  327.   if (row_offset) iptr += row_offset * orow_size;
  328.   orow_size *= interleave;
  329.   if (interleave == 2) imagey >>= 1;
  330.   imagex++; imagex >>= 1;
  331.  
  332.   qtab0 = jpg_quant_tables[ jpg_comps[0].qtbl_num ];
  333.   qtab1 = jpg_quant_tables[ jpg_comps[1].qtbl_num ];
  334.   qtab2 = jpg_quant_tables[ jpg_comps[2].qtbl_num ];
  335.  
  336.   mcu_cols = (width  + 15) / 16;
  337.   mcu_rows = (height +  7) / 8;
  338.   // DEBUG_LEVEL1 kprintf("211111 begin MCUS(%d,%d)\n",mcu_cols,mcu_rows);
  339.   jpg_marker = 0x00;
  340.  
  341.   rst_count = jpg_rst_interval;
  342.   while(mcu_rows--)
  343.   {
  344.     Ybuf = yuvBuf->yBuf; Ubuf = yuvBuf->uBuf; Vbuf = yuvBuf->vBuf;
  345.     x = mcu_cols;
  346.     while(x--)
  347.     { /* DEBUG_LEVEL1 kprintf("MCU XY(%d,%d)\n", x,mcu_rows); */
  348.  
  349.       JPG_HANDLE_RST(jpg_rst_interval,rst_count);
  350.  
  351.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  352.       jpg_huffparse(&jpg_comps[0],jpg_dct_buf,qtab0,Ybuf); Ybuf += DCTSIZE2;
  353.       jpg_huffparse(&jpg_comps[1],jpg_dct_buf,qtab1,Ubuf); Ubuf += DCTSIZE2;
  354.       jpg_huffparse(&jpg_comps[2],jpg_dct_buf,qtab2,Vbuf); Vbuf += DCTSIZE2;
  355.       JPG_TST_MARKER(jpg_rst_interval,rst_count);
  356.     } /* end of mcu_cols */
  357.  
  358.     // (void)(color_func)(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2), orow_size, &jpg_YUVBufs,&def_yuv_tabs, map_flag,map,chdr);
  359.     mjpamcu211111(iptr,imagex,xaMIN(imagey,8),(mcu_cols * DCTSIZE2), orow_size);
  360.     // imagey -= 8;  iptr += (orow_size << 3);
  361.     imagey -= 8;  iptr += (orow_size << 4);
  362.  
  363.   } /* end of mcu_rows */
  364.   if (jpg_marker) { jpg_h_bbuf = 0; jpg_h_bnum = 0; }
  365.   return(xaTRUE);
  366. }
  367. /* \\\ */
  368.  
  369. /* /// "SelectMJPAFuncs()" */
  370. __asm void SelectMJPAFuncs(REG(a0) struct MJPAData *spec,
  371.                            REG(d0) uchar _gray,
  372.                            REG(d1) uchar _dither)
  373. {
  374.   ulong x;
  375.  
  376.   for (x=0; x<JJ_NUM_QUANT_TBLS; x++) jpg_quant_tables[x]=spec->quantTab[x];
  377.   if (_gray) {
  378.     bytes_pixel=1;
  379.     mjpamcu211111=mjpaMCU211111to332;
  380.   } else if (_dither) {
  381.     bytes_pixel=1;
  382.     mjpamcu211111=mjpaMCU211111to332Dith;
  383.   } else {
  384.     bytes_pixel=4;
  385.     mjpamcu211111=mjpaMCU211111toRGB;
  386.   }
  387. }
  388. /* \\\ */
  389.  
  390. /* /// "DecodeMJPA()" */
  391. __asm void DecodeMJPA(REG(a0) uchar *delta,
  392.                       REG(a1) uchar *image,
  393.                       REG(d0) ulong myWidth,
  394.                       REG(d1) ulong myHeight,
  395.                       REG(d2) ulong dsize,
  396.                       REG(a2) struct MJPAData *spec)
  397. {
  398.   ulong imagex = myWidth;
  399.   ulong imagey = myHeight;
  400.   // void *extra = dec_info->extra;
  401.   long base_y;
  402.   ulong jpg_type;
  403.   ulong interleave,row_offset;
  404.  
  405.   // jpg_type = (ulong)(extra);
  406.   jpg_type=0x00;
  407.   // xa_mjpg_kludge = (jpg_type & 0x40)?(0x40):(0x00);
  408.   xa_mjpg_kludge=0x00;
  409.  
  410. /* init buffer stuff */
  411.   jpg_init_input(delta,dsize);
  412.  
  413.   base_y = 0;
  414.   while(base_y < imagey)
  415.   {
  416.     jpg_saw_EOI = jpg_saw_DHT = xaFALSE;
  417.     // hier war der ganze IJPG-Kram
  418.     {
  419.       /* read markers */
  420.       jpg_saw_SOI = jpg_saw_SOF = jpg_saw_SOS = jpg_saw_DHT = jpg_saw_DQT = xaFALSE;
  421.       if (jpg_read_markers() == xaFALSE) {
  422.         // jpg_free_stuff();
  423.         // kprintf("JPG: rd marker err\n");
  424.         return;
  425.       }
  426.       jpg_huff_reset();
  427.  
  428.       interleave = (jpg_height <= ((imagey>>1)+1) )?(2):(1);
  429.       row_offset = ((interleave == 2) && (base_y == 0))?(1):(0);
  430.     }
  431.     jpg_marker = 0x00;
  432.     // if (jpg_width > imagex) JPG_Alloc_MCU_Bufs(0,jpg_width,0,xaFALSE);
  433.  
  434.  
  435.     if ((jpg_saw_DHT != xaTRUE) && (jpg_std_DHT_flag==0))
  436.     {
  437.       // DEBUG_LEVEL1 kprintf("standard DHT tables\n");
  438.       jpg_std_DHT();
  439.     }
  440.     // DEBUG_LEVEL1 kprintf("JJ: imagexy %d %d  jjxy %d %d basey %d\n",imagex,imagey,jpg_width,jpg_height,base_y);
  441.  
  442.     if (   (jpg_num_comps == 3) && (jpg_comps_in_scan == 3)
  443.         && (jpg_comps[1].hvsample == 0x11) && (jpg_comps[2].hvsample== 0x11) )
  444.     {
  445.       if (jpg_comps[0].hvsample == 0x21) /* 211 */
  446.         { mjpa_decode_211111(image,jpg_width,jpg_height,interleave,row_offset,
  447.                         imagex,imagey); }
  448.       else
  449.       { // kprintf("JPG: cmps %d %d mcu %04x %04x %04x unsupported\n",
  450.         //         jpg_num_comps,jpg_comps_in_scan,jpg_comps[0].hvsample,
  451.         //         jpg_comps[1].hvsample,jpg_comps[2].hvsample);
  452.         break;
  453.       }
  454.     }
  455.     else
  456.     { // kprintf("JPG: cmps %d %d mcu %04x %04x %04x unsupported.\n",
  457.       //           jpg_num_comps,jpg_comps_in_scan,jpg_comps[0].hvsample,
  458.       //           jpg_comps[1].hvsample,jpg_comps[2].hvsample);
  459.       break;
  460.     }
  461.  
  462.     base_y += ((interleave == 1)?(imagey):(jpg_height));
  463.     if (jpg_marker == M_EOI) { jpg_saw_EOI = xaTRUE; jpg_marker = 0x00; }
  464.     else if (jpg_saw_EOI==xaFALSE) if (jpg_read_EOI_marker() == xaFALSE) break;
  465.   }
  466.   return;
  467. }
  468. /* \\\ */
  469.  
  470.